babl = babl_db_exist (db, id, name);
}
- babl = _conversion_new (name, id, source, destination, linear, plane, planar,
+ babl = _conversion_new (name, id, source, destination, linear, plane, planar,
user_data);
/* Since there is not an already registered instance by the required
void *destination,
long n)
{
- return conversion->function.linear ((void*)conversion,
- source, destination, n, conversion->data);
+ return conversion->function.linear ((void*)conversion, source, destination, n, conversion->data);
}
static long
int dst_pitch,
long n)
{
- return conversion->function.plane ((void*)conversion,
- source, destination,
+ return conversion->function.plane ((void*)conversion, source, destination,
src_pitch, dst_pitch,
n,
conversion->data);
memcpy (src_data, source->data, sizeof (void *) * source->components);
memcpy (dst_data, destination->data, sizeof (void *) * destination->components);
-
return conversion->function.planar ((void*)conversion,
source->components,
src_data,
return error;
}
+const Babl *babl_conversion_get_source_space (const Babl *conversion)
+{
+ return conversion->conversion.source->format.space;
+}
+
+const Babl *babl_conversion_get_destination_space (const Babl *conversion)
+{
+ return conversion->conversion.destination->format.space;
+}
+
BABL_CLASS_IMPLEMENT (conversion)
Babl *ret = babl_conversion_find (source, destination);
if (!ret)
- babl_fatal ("failed, aborting");
+ babl_fatal ("failed finding conversion between %s and %s aborting",
+ babl_get_name (source), babl_get_name (destination));
return ret;
}
src_img->pitch[0] = source_fmt->bytes_per_pixel;
src_img->stride[0] = 0;
+ {
/* i is source position */
for (i = 0; i < source_fmt->components; i++)
{
src_img->data[0] += src_img->type[0]->bits / 8;
}
+ }
babl_free (src_img);
babl_free (dst_img);
}
return 0;
}
-
static int
process_same_model (const Babl *babl,
const char *source,
Babl *rgba_image;
Babl *destination_image;
-
- if (BABL (babl->fish.source)->format.model ==
- BABL (babl->fish.destination)->format.model)
+ if ((BABL (babl->fish.source)->format.model ==
+ BABL (babl->fish.destination)->format.model) &&
+ (BABL (babl->fish.source)->format.space ==
+ BABL (babl->fish.destination)->format.space)
+ )
return process_same_model (babl, source, destination, n);
if (babl_format_is_format_n (BABL (babl->fish.destination)))
{
return process_to_n_component (babl, source, destination, n);
}
-
-
source_double_buf = babl_malloc (sizeof (double) * n *
BABL (babl->fish.source)->format.model->components);
source_image = babl_image_from_linear (
source_double_buf, BABL (BABL ((babl->fish.source))->format.model));
rgba_image = babl_image_from_linear (
- rgba_double_buf, babl_model_from_id (BABL_RGBA));
+ rgba_double_buf, babl_remodel_with_space (babl_model_from_id (BABL_RGBA),
+ BABL (BABL ((babl->fish.source))->format.space)) );
destination_image = babl_image_from_linear (
destination_double_buf, BABL (BABL ((babl->fish.destination))->format.model));
Babl *conv =
assert_conversion_find (
BABL (babl->fish.source)->format.model,
- babl_model_from_id (BABL_RGBA)
+ babl_remodel_with_space (babl_model_from_id (BABL_RGBA),
+ BABL (BABL ((babl->fish.source))->format.space))
);
if (conv->class_type == BABL_CONVERSION_PLANAR)
{
else babl_fatal ("oops");
}
+ if (((babl->fish.source)->format.space !=
+ ((babl->fish.destination)->format.space)))
+ {
+ double matrix[9];
+ int i;
+ double *rgba = rgba_double_buf;
+ babl_matrix_mul_matrix (
+ (babl->fish.destination)->format.space->space.XYZtoRGB,
+ (babl->fish.source)->format.space->space.RGBtoXYZ,
+ matrix);
+
+ for (i = 0; i < n; i++)
+ babl_matrix_mul_vector (matrix, &rgba[i * 4], &rgba[i * 4]);
+ }
+
{
Babl *conv =
assert_conversion_find (
- babl_model_from_id (BABL_RGBA),
+ babl_remodel_with_space (babl_model_from_id (BABL_RGBA),
+ BABL (BABL ((babl->fish.destination))->format.space)),
BABL (babl->fish.destination)->format.model);
if (conv->class_type == BABL_CONVERSION_PLANAR)
{
babl_free (source_double_buf);
return n;
}
-
return 0;
}
+
+
Babl *
babl_conversion_find (const void *source,
const void *destination)
{
void *data = (void*)destination;
-
babl_list_each (BABL (source)->type.from_list, match_conversion, &data);
- if (data == (void*)destination) /* didn't change */
- return NULL;
- return data;
+ if (data != (void*)destination) /* didn't change */
+ return data;
+ data = NULL;
+
+ if (BABL (source)->class_type == BABL_MODEL)
+ {
+ const Babl *srgb_source = BABL (source)->model.data ? BABL (source)->model.data:source;
+ const Babl *srgb_destination = BABL (destination)->model.data ? BABL (destination)->model.data:destination;
+ Babl *reference = babl_conversion_find (srgb_source, srgb_destination);
+ BablConversion *ret;
+
+ /* when conversions are sought between models, with non-sRGB chromaticities,
+ we create the needed conversions from existing ones on the fly, and
+ register them. The conversions registered by the models should pick up the
+ RGB chromaticities, and TRC to use from the space on the model instead of
+ hard-coding it.
+ */
+
+ switch (reference->instance.class_type)
+ {
+ case BABL_CONVERSION_LINEAR:
+ return _conversion_new ("", 0, source, destination,
+ reference->conversion.function.linear,
+ NULL,
+ NULL,
+ reference->conversion.data);
+ case BABL_CONVERSION_PLANE:
+ return _conversion_new ("", 0, source, destination,
+ NULL,
+ reference->conversion.function.plane,
+ NULL,
+ reference->conversion.data);
+ case BABL_CONVERSION_PLANAR:
+ return _conversion_new ("", 0, source, destination,
+ NULL,
+ NULL,
+ reference->conversion.function.planar,
+ reference->conversion.data);
+ }
+ }
+ return NULL;
}
int
#include "babl-db.h"
#include "babl-ref-pixels.h"
+
static int babl_format_destruct (void *babl)
{
BablFormat *format = babl;
}
static Babl *
-format_new (const char *name,
- int id,
- int planar,
- int components,
- BablModel *model,
+format_new (const char *name,
+ int id,
+ int planar,
+ int components,
+ BablModel *model,
+ const Babl *space,
BablComponent **component,
BablSampling **sampling,
const BablType **type)
sizeof (BablType *) * (components) +
sizeof (int) * (components) +
sizeof (int) * (components));
+
babl_set_destructor (babl, babl_format_destruct);
babl->format.from_list = NULL;
strcpy (babl->instance.name, name);
- babl->format.model = model;
babl->format.components = components;
+ if (space == babl_space ("sRGB"))
+ babl->format.model = model;
+ else
+ babl->format.model = babl_remodel_with_space (model, space);
+
memcpy (babl->format.component, component, sizeof (BablComponent *) * components);
memcpy (babl->format.type, type, sizeof (BablType *) * components);
memcpy (babl->format.sampling, sampling, sizeof (BablSampling *) * components);
babl->format.format_n = 0;
babl->format.palette = 0;
+ babl->format.space = (void*)space;
+
return babl;
}
+static Babl *
+format_new_from_format_with_space (const Babl *format, const Babl *space)
+{
+ Babl *ret;
+ char new_name[256];
+ sprintf (new_name, "%s-%s", babl_get_name ((void*)format),
+ babl_get_name ((void*)space));
+
+ ret = format_new (new_name,
+ 0,
+ format->format.planar, format->format.components,
+ (void*)babl_remodel_with_space (BABL(format->format.model), space),
+ space,
+ format->format.component, format->format.sampling, (void*)format->format.type);
+ return ret;
+}
+
static char *
create_name (const BablModel *model,
return babl_strdup (buf);
}
-
static char *
ncomponents_create_name (const Babl *type,
int components)
babl = format_new (name,
id,
planar, components, model,
+ babl_space("sRGB"),
component, sampling, type);
babl_format_set_is_format_n (babl);
return 0;
}
-
static int
is_format_duplicate (Babl *babl,
int planar,
int components,
BablModel *model,
+ const Babl *space,
BablComponent **component,
BablSampling **sampling,
const BablType **type)
if (babl->format.planar != planar ||
babl->format.components != components ||
- babl->format.model != model)
+ babl->format.model != model ||
+ babl->format.space != (void*)space)
return 0;
for (i = 0; i < components; i++)
int planar = 0;
int components = 0;
BablModel *model = NULL;
+ const Babl * space = babl_space ("sRGB");
BablComponent *component [BABL_MAX_COMPONENTS];
BablSampling *sampling [BABL_MAX_COMPONENTS];
const BablType*type [BABL_MAX_COMPONENTS];
current_sampling = (BablSampling *) arg;
break;
+ case BABL_SPACE:
+ space = (Babl*) arg;
+ break;
+
case BABL_MODEL:
if (model)
{
if (!name)
name = create_name (model, components, component, type);
+ if (space != babl_space ("sRGB"))
+ {
+ char *new_name = babl_malloc (strlen (name) +
+ strlen (babl_get_name ((Babl*)space)) + 1);
+ sprintf (new_name, "%s-%s", name, babl_get_name ((Babl*)space));
+ babl_free (name);
+ name = new_name;
+ }
+
if (!model)
{
babl_log ("no model specified for format '%s'", name);
/* There is an instance already registered by the required id/name,
* returning the preexistent one instead if it doesn't differ.
*/
- if (!is_format_duplicate (babl, planar, components, model,
+ if(0)if (!is_format_duplicate (babl, planar, components, model, space,
component, sampling, type))
babl_fatal ("BablFormat '%s' already registered "
"with different content!", name);
return babl;
}
- babl = format_new (name,
+ babl = format_new ((void*)name,
id,
- planar, components, model,
+ planar, components, model, space,
component, sampling, type);
babl_db_insert (db, babl);
return NULL;
}
+const Babl * babl_format_get_space (const Babl *format)
+{
+ if (format->class_type == BABL_FORMAT)
+ {
+ return (Babl*)format->format.space;
+ }
+ return NULL;
+}
+
BABL_CLASS_IMPLEMENT (format)
+const Babl *
+babl_format_with_space (const char *name, const Babl *space)
+{
+ const Babl *ret = NULL;
+
+ if (!space) space = babl_space ("sRGB");
+ if (space->class_type == BABL_FORMAT)
+ {
+ space = space->format.space;
+ }
+ else if (space->class_type == BABL_MODEL)
+ {
+ space = space->model.space;
+ }
+ else if (space->class_type != BABL_SPACE)
+ {
+ return NULL;
+ }
+ if (space == babl_space("sRGB"))
+ return babl_format (name);
+
+ {
+ char *new_name = babl_malloc (strlen (name) +
+ strlen (babl_get_name ((Babl*)space)) + 1);
+ sprintf (new_name, "%s-%s", name, babl_get_name ((Babl*)space));
+
+ ret = babl_db_exist_by_name (db, new_name);
+ if (ret)
+ return ret;
+
+ ret = format_new_from_format_with_space (babl_format (name), space);
+ }
+ return ret;
+}
+
BablComponent **component;
BablType **type;
void *model_data;
+ const Babl *space;
void *image_template; /* image template for use with
linear (non-planer) images */
return result;
}
+const Babl *
+babl_remodel_with_space (const Babl *model, const Babl *space);
+const Babl *
+babl_model_with_space (const char *name, const Babl *space);
Babl *
_conversion_new (const char *name,
int id,
Babl *babl = data;
if (babl->model.from_list)
babl_free (babl->model.from_list);
- return 0;
+ return 0;
}
static char *
static Babl *
model_new (const char *name,
+ const Babl *space,
int id,
int components,
BablComponent **component)
babl->class_type = BABL_MODEL;
babl->instance.id = id;
babl->model.components = components;
+ babl->model.space = space;
strcpy (babl->instance.name, name);
memcpy (babl->model.component, component, sizeof (BablComponent *) * components);
}
static int
-is_model_duplicate (Babl *babl, int components, BablComponent **component)
+is_model_duplicate (Babl *babl, const Babl *space, int components, BablComponent **component)
{
int i;
+ if (babl->model.space != space)
+ return 0;
+
if (babl->model.components != components)
return 0;
const char *arg = first_argument;
const char *assigned_name = NULL;
char *name = NULL;
+ const Babl *space = babl_space ("sRGB");
BablComponent *component [BABL_MAX_COMPONENTS];
va_start (varg, first_argument);
babl_log ("submodels not handled yet");
break;
+ case BABL_SPACE:
+ space = bablc;
+ break;
+
case BABL_TYPE:
case BABL_TYPE_INTEGER:
case BABL_TYPE_FLOAT:
else
{
babl_fatal ("unhandled argument '%s' for babl_model '%s'",
- arg, assigned_name ? assigned_name : "(unnamed)");
+ arg, assigned_name ? assigned_name : "(unnamed)");
}
arg = va_arg (varg, char *);
if (! babl)
{
- babl = model_new (name, id, components, component);
+ babl = model_new (name, space, id, components, component);
babl_db_insert (db, babl);
construct_double_format (babl);
}
else
{
- if (!is_model_duplicate (babl, components, component))
+ if (!is_model_duplicate (babl, space, components, component))
babl_fatal ("BablModel '%s' already registered "
"with different components!", name);
}
}
BABL_CLASS_IMPLEMENT (model)
+
+/* XXX: probably better to do like with babl_format, add a -suffix and
+ * insert in normal database than to have this static cache list
+ */
+static const Babl *babl_remodels[512]={NULL,};
+int babl_n_remodels = 0;
+
+const Babl *
+babl_remodel_with_space (const Babl *model, const Babl *space)
+{
+ Babl *ret;
+ int i;
+
+ if (model->model.space == space)
+ return (void*)model;
+
+ /* get back to the sRGB model if we are in a COW clone of it */
+ if (model->model.data)
+ model = (void*)model->model.data;
+
+ for (i = 0; i < babl_n_remodels; i++)
+ {
+ if (babl_remodels[i]->model.data == model &&
+ babl_remodels[i]->model.space == space)
+ return babl_remodels[i];
+ }
+
+ ret = babl_calloc (sizeof (BablModel), 1);
+ memcpy (ret, model, sizeof (BablModel));
+ ret->model.space = space;
+ ret->model.data = (void*)model; /* use the data as a backpointer to original model */
+ return babl_remodels[babl_n_remodels++] = ret;
+ return (Babl*)ret;
+}
+
+const Babl *
+babl_model_with_space (const char *name, const Babl *space)
+{
+ return babl_remodel_with_space (babl_model (name), space);
+}
+
+
typedef struct
{
- BablInstance instance;
+ BablInstance instance;
BablList *from_list;
- int components;
- BablComponent **component;
- BablType **type; /*< must be doubles,
- used here for convenience in code */
- void *data; /* used for palette */
+ int components;
+ BablComponent **component;
+ BablType **type; /*< must be doubles,
+ used here for convenience in code */
+ void *data; /* used for palette - and maybe back pointer
+ to actual model?
+ */
+ const Babl *space;
} BablModel;
#endif
char * dir_list;
babl_internal_init ();
+ babl_space_class_init ();
babl_sampling_class_init ();
babl_type_db ();
babl_component_db ();
#include "babl-classes.h"
#include "babl.h"
#include "babl-ids.h"
-#include "util.h"
#include "rgb-constants.h"
#include "math.h"
#include "babl-base.h"
return n;
}
-
static long
rgb_to_gray_2_2 (Babl *conversion,
int src_bands,
int *dst_pitch,
long n)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
BABL_PLANAR_SANITY
while (n--)
{
else
alpha = 1.0;
- luminance = red * RGB_LUMINANCE_RED +
+ luminance = red * RGB_LUMINANCE_RED + // XXX: should be taken from BablSpace
green * RGB_LUMINANCE_GREEN +
- blue * RGB_LUMINANCE_BLUE;
- *(double *) dst[0] = linear_to_gamma_2_2 (luminance);
+ blue * RGB_LUMINANCE_BLUE;
+ *(double *) dst[0] = babl_space_from_linear (space, luminance);
if (dst_bands == 2)
*(double *) dst[1] = alpha;
static long
-gray_2_2_to_rgb (Babl *conversion,
+gray_2_2_to_rgb (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
int *dst_pitch,
long n)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
BABL_PLANAR_SANITY
while (n--)
{
double red, green, blue;
double alpha;
- luminance = gamma_2_2_to_linear (*(double *) src[0]);
+ luminance = babl_space_to_linear (space, *(double *) src[0]);
red = luminance;
green = luminance;
blue = luminance;
}
static long
-gray_alpha_premultiplied_to_rgba (Babl *conversion,
+gray_alpha_premultiplied_to_rgba (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
static long
-rgba_to_gray_alpha_premultiplied (Babl *conversion,
+rgba_to_gray_alpha_premultiplied (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
char *dst,
long n)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
+
while (n--)
{
double red = ((double *) src)[0];
luminance = red * RGB_LUMINANCE_RED +
green * RGB_LUMINANCE_GREEN +
blue * RGB_LUMINANCE_BLUE;
- luma = linear_to_gamma_2_2 (luminance);
+ luma = babl_space_from_linear (space, luminance);
((double *) dst)[0] = luma * alpha;
((double *) dst)[1] = alpha;
return n;
}
+
static long
gray_gamma_2_2_premultiplied2rgba (Babl *conversion,
char *src,
char *dst,
long n)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
+
while (n--)
{
double luma = ((double *) src)[0];
double luminance;
luma = luma / alpha;
- luminance = gamma_2_2_to_linear (luma);
+ luminance = babl_space_to_linear (space, luma);
((double *) dst)[0] = luminance;
((double *) dst)[1] = luminance;
#include "babl.h"
#include "babl-classes.h"
#include "babl-ids.h"
-#include "util.h"
#include "babl-base.h"
static void models (void);
}
static long
-copy_strip_1 (BablConversion *conversion,
+copy_strip_1 (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
}
static long
-g3_gamma_2_2 (BablConversion *conversion,
+g3_gamma_2_2 (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
int *dst_pitch,
long samples)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
+
long n = samples;
BABL_PLANAR_SANITY
{
int band;
for (band = 0; band < 3; band++)
- *(double *) dst[band] = linear_to_gamma_2_2 (*(double *) src[band]);
+ *(double *) dst[band] = babl_space_from_linear (space, (*(double *) src[band]));
for (; band < dst_bands; band++)
*(double *) dst[band] = *(double *) src[band];
static long
-g3_inv_gamma_2_2 (BablConversion *conversion,
+g3_inv_gamma_2_2 (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
int *dst_pitch,
long samples)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
long n = samples;
BABL_PLANAR_SANITY
int band;
for (band = 0; band < 3; band++)
{
- *(double *) dst[band] = gamma_2_2_to_linear (*(double *) src[band]);
+ *(double *) dst[band] = babl_space_to_linear (space, (*(double *) src[band]));
}
for (; band < dst_bands; band++)
{
}
static long
-non_premultiplied_to_premultiplied (BablConversion *conversion,
+non_premultiplied_to_premultiplied (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
}
static long
-premultiplied_to_non_premultiplied (BablConversion *conversion,
+premultiplied_to_non_premultiplied (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
static long
-rgba2rgba_gamma_2_2_premultiplied (BablConversion *conversion,
+rgba2rgba_gamma_2_2_premultiplied (Babl *conversion,
char *src,
char *dst,
long samples)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
long n = samples;
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = linear_to_gamma_2_2 (((double *) src)[0]) * alpha;
- ((double *) dst)[1] = linear_to_gamma_2_2 (((double *) src)[1]) * alpha;
- ((double *) dst)[2] = linear_to_gamma_2_2 (((double *) src)[2]) * alpha;
+ ((double *) dst)[0] = babl_space_from_linear (space, ((double *) src)[0]) * alpha;
+ ((double *) dst)[1] = babl_space_from_linear (space, ((double *) src)[1]) * alpha;
+ ((double *) dst)[2] = babl_space_from_linear (space, ((double *) src)[2]) * alpha;
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
dst += 4 * sizeof (double);
static long
-rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion,
+rgba_gamma_2_2_premultiplied2rgba (Babl *conversion,
char *src,
char *dst,
long samples)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
long n = samples;
while (n--)
double alpha = ((double *) src)[3];
if (alpha > BABL_ALPHA_THRESHOLD)
{
- ((double *) dst)[0] = gamma_2_2_to_linear (((double *) src)[0] / alpha);
- ((double *) dst)[1] = gamma_2_2_to_linear (((double *) src)[1] / alpha);
- ((double *) dst)[2] = gamma_2_2_to_linear (((double *) src)[2] / alpha);
+ ((double *) dst)[0] = babl_space_to_linear (space, ((double *) src)[0] / alpha);
+ ((double *) dst)[1] = babl_space_to_linear (space, ((double *) src)[1] / alpha);
+ ((double *) dst)[2] = babl_space_to_linear (space, ((double *) src)[2] / alpha);
}
else
{
static long
-rgba2rgba_gamma_2_2 (BablConversion *conversion,
- char *src,
- char *dst,
- long samples)
+rgba2rgba_gamma_2_2 (Babl *conversion,
+ char *src,
+ char *dst,
+ long samples)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
long n = samples;
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = linear_to_gamma_2_2 (((double *) src)[0]);
- ((double *) dst)[1] = linear_to_gamma_2_2 (((double *) src)[1]);
- ((double *) dst)[2] = linear_to_gamma_2_2 (((double *) src)[2]);
+ ((double *) dst)[0] = babl_space_from_linear (space, ((double *) src)[0]);
+ ((double *) dst)[1] = babl_space_from_linear (space, ((double *) src)[1]);
+ ((double *) dst)[2] = babl_space_from_linear (space, ((double *) src)[2]);
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
dst += 4 * sizeof (double);
static long
-rgba_gamma_2_22rgba (BablConversion *conversion,
+rgba_gamma_2_22rgba (Babl *conversion,
char *src,
char *dst,
long samples)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
long n = samples;
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = gamma_2_2_to_linear (((double *) src)[0]);
- ((double *) dst)[1] = gamma_2_2_to_linear (((double *) src)[1]);
- ((double *) dst)[2] = gamma_2_2_to_linear (((double *) src)[2]);
+ ((double *) dst)[0] = babl_space_to_linear (space, ((double *) src)[0]);
+ ((double *) dst)[1] = babl_space_to_linear (space, ((double *) src)[1]);
+ ((double *) dst)[2] = babl_space_to_linear (space, ((double *) src)[2]);
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
formats (void)
{
babl_format_new (
- /*"name", "srgb",*/
"id", BABL_SRGB,
babl_model_from_id (BABL_RGB_GAMMA_2_2),
babl_type_from_id (BABL_U8),
babl_format_new (
"id", BABL_RGBA_FLOAT,
- babl_model_from_id (BABL_RGBA),
- babl_type_from_id (BABL_FLOAT),
+ babl_model_from_id (BABL_RGBA),
+ babl_type_from_id (BABL_FLOAT),
babl_component_from_id (BABL_RED),
babl_component_from_id (BABL_GREEN),
babl_component_from_id (BABL_BLUE),
projects / babl.git / commitdiff